package ru.ifmo.contest.games;

import java.io.*;
import java.util.StringTokenizer;

/**
 * @author avhaliullin
 */

public class TaskB {
    FastScanner in;
    PrintWriter out;

    boolean canGo(int x, int y) {
        return x >= 0 && x < n && y >= 0 && y < n && !badPositions[getCellPosition(x, y)];
    }

    int[] mask = new int[]{1, 2, 4, 8, -1, 16, 32, 64, 128};

    int getParentMask(int xv, int yv) {
        return mask[(xv + 1) * 3 + yv + 1];
    }

    int getYVByMask(int mask) {
        switch (mask) {
            case 1:
                return -1;
            case 2:
                return 0;
            case 4:
                return 1;
            case 8:
                return -1;
            case 16:
                return 1;
            case 32:
                return -1;
            case 64:
                return 0;
            case 128:
                return 1;
        }
        return -100;
    }

    int getXVByMask(int mask) {
        switch (mask) {
            case 1:
                return -1;
            case 2:
                return -1;
            case 4:
                return -1;
            case 8:
                return 0;
            case 16:
                return 0;
            case 32:
                return 1;
            case 64:
                return 1;
            case 128:
                return 1;
        }
        return -100;
    }

    int parentByChildAndMask(int child, int mask) {
        int revert = (child % n2) * n2 + child / n2;
        return revert - getXVByMask(mask) * n3 - getYVByMask(mask) * n2;
    }

    boolean go(int current, int x2, int y2, int xv, int yv, int childPosNum) {
        if (canGo(x2 + xv, y2 + yv)) {
            childrenCount[current]++;
            parents[childPosNum] |= getParentMask(xv, yv);
            return true;
        } else {
            return false;
        }
    }

    State[] game;
    MyQueue queue;
    boolean[] badPositions;

    int[] parents;
    int[] childrenCount;
    int n, m, xs1, xs2, ys1, ys2, n4, n3, n2;

    public void solve() throws IOException {
        n = in.nextInt();
        m = in.nextInt();
        n2 = n * n;
        n3 = n2 * n;
        n4 = n3 * n;

        parents = new int[n4];
        childrenCount = new int[n4];
        badPositions = new boolean[n2];
        game = new State[n4];
        queue = new MyQueue(n4 / 2);

        xs1 = in.nextInt() - 1;
        ys1 = in.nextInt() - 1;
        xs2 = in.nextInt() - 1;
        ys2 = in.nextInt() - 1;

        for (int i = 0; i < m; i++) {
            badPositions[getCellPosition(in.nextInt() - 1, in.nextInt() - 1)] = true;
        }

        int currentPosition = -1;
        for (int x2 = 0; x2 < n; x2++) {
            for (int y2 = 0; y2 < n; y2++) {
                if (!badPositions[getCellPosition(x2, y2)]) {
                    for (int x1 = 0; x1 < n; x1++) {
                        for (int y1 = 0; y1 < n; y1++) {
                            currentPosition++;
                            if (!(x1 == x2 && y1 == y2) && !badPositions[getCellPosition(x1, y1)]) {
                                int posNum = getGamePosition(x1, y1, x2, y2);

                                if (Math.abs(x1 - x2) <= 1 && Math.abs(y1 - y2) <= 1) {
                                    game[posNum] = State.WIN;
                                    queue.offer(posNum);
                                    continue;
                                }
                                if (!((x1 > 0 && (go(posNum, x1, y1, -1, 0, currentPosition - n) |
                                        go(posNum, x1, y1, -1, -1, currentPosition - 1 - n) |
                                        go(posNum, x1, y1, -1, 1, currentPosition - n + 1))) |
                                        go(posNum, x1, y1, 0, 1, currentPosition + 1) |
                                        (x1 < n - 1 && (go(posNum, x1, y1, 1, 1, currentPosition + n + 1) |
                                                go(posNum, x1, y1, 1, 0, currentPosition + n) |
                                                go(posNum, x1, y1, 1, -1, currentPosition + n - 1))) |
                                        go(posNum, x1, y1, 0, -1, currentPosition - 1))) {
                                    game[posNum] = State.LOOSE;
                                    queue.offer(posNum);
                                }
                            }
                        }
                    }
                } else {
                    currentPosition += n2;
                }
            }
        }

        while (!queue.isEmpty()) {
            int current = queue.poll();
            if (State.LOOSE.equals(game[current])) {
                for (int parent = 1; parent < 256; parent *= 2) {
                    if ((parent & parents[current]) > 0) {
                        int parentId = parentByChildAndMask(current, parent);
                        if (game[parentId] == null) {
                            game[parentId] = State.WIN;
                            queue.offer(parentId);
                        }
                    }
                }
            } else {
                for (int parent = 1; parent < 256; parent *= 2) {
                    if ((parent & parents[current]) > 0) {
                        int parentId = parentByChildAndMask(current, parent);
                        if ((--childrenCount[parentId]) == 0) {
                            game[parentId] = State.LOOSE;
                            queue.offer(parentId);
                        }
                    }
                }
            }
        }
        State state = game[getGamePosition(xs1, ys1, xs2, ys2)];
        if (State.LOOSE.equals(state)) {
            out.println("Black");
        }
        if (State.WIN.equals(state)) {
            out.println("White");
        }
        if (state == null) {
            out.println("Draw");
        }

    }

    public void run(String fileName) {
        try {
            in = new FastScanner(new File(fileName + ".in"));
            out = new PrintWriter(new File(fileName + ".out"));

            solve();

            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    enum State {
        WIN,
        LOOSE
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }
    }

    int getGamePosition(int x1, int y1, int x2, int y2) {
        return getCellPosition(x1, y1) * n * n + getCellPosition(x2, y2);
    }

    int getCellPosition(int x, int y) {
        return x * n + y;
    }

    public static void main(String[] arg) {
        new TaskB().run("gameofthrones");
    }

    class MyQueue {
        int head = 0;
        int tail = 0;
        int[] buf;

        MyQueue(int size) {
            buf = new int[size];
        }

        public void offer(int node) {
            buf[tail] = node;
            tail = (tail + 1) % buf.length;
        }

        public boolean isEmpty() {
            return head == tail;
        }

        public int poll() {
            int result = buf[head];
            head = (head + 1) % buf.length;
            return result;
        }
    }
}
